#include "UART/uart_app.h"
#include "usart.h"
#include "math.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>

/**
 ****************************************************************************************************
 * DONE 用户变量区
 ****************************************************************************************************
 */
#define USART_HEADER1 "PID"
#define USART_HEADER2 "CON"
#define USART_HEADER3 "RUN"
#define USART_TAIL    "END"
#define USART_HEADER_LENGTH 3
#define USART_TAIL_LENGTH 3

#define FRAME_HEADER1 "SHIP"
#define FRAME_HEADER2 "CONN"
#define FRAME_TAIL    "END"

#define FRAME_HEADER_LENGTH 4
#define FRAME_TAIL_LENGTH 3

//串口1-bearpi
//接受数据索引
uint16_t usart1_rxIndex = 0;
//接收完成标志
uint8_t Receivedsuccee_Flag = 0;

uint16_t usart1_packet_len;       
uint8_t usart1_ready; // 设置标志位

//GPS
uint8_t GPS_START_FLAG = 0;

uint8_t rxBuffer_1[RX_BUFFER_SIZE];  // 接收缓冲区
uint8_t txBuffer_1[TX_BUFFER_SIZE]; // 发送缓冲区
uint8_t rxBuffer_2[RX_BUFFER_SIZE];  // 接收缓冲区
uint8_t txBuffer_2[TX_BUFFER_SIZE]; // 发送缓冲区
uint8_t rxBuffer_3[RX_BUFFER_SIZE];  // 接收缓冲区
uint8_t txBuffer_3[TX_BUFFER_SIZE]; // 发送缓冲区
uint8_t rxBuffer_4[RX_BUFFER_SIZE];  // 接收缓冲区
uint8_t txBuffer_4[TX_BUFFER_SIZE]; // 发送缓冲区

uint16_t USART1_RX_STA=0;//接收状态标记//bit15：接收完成标志，bit14：接收到0x0d，bit13~0：接收到的有效字节数目
uint8_t USART1_NewData;//当前串口中断接收的1个字节数据的缓存

volatile uint16_t rxIndex_1 = 0;    // 接收索引
volatile uint16_t rxIndex_2 = 0;    // 接收索引
volatile uint16_t rxIndex_3 = 0;    // 接收索引
volatile uint16_t rxIndex_4 = 0;    // 接收索引

// 串口发送
UART_HandleTypeDef *bear_huart = &huart1;
UART_HandleTypeDef *G4_huart = &huart2;
UART_HandleTypeDef *bt24_huart = &huart3;
UART_HandleTypeDef *Test_huart = &huart4;

uint8_t HMI_arry[RX_BUFFER_SIZE] = {0};  // 用于存储接收到的数据帧
uint8_t HMI_arry_length = 0;       // 当前接收到的数据长度


uint8_t GPS_arry[BUFF_MAX] = {0};  // 用于存储接收到的数据帧
uint8_t GPS_arry_length = 0;       // 当前接收到的数据长度

datapackage txdatapackage;

/**
 ****************************************************************************************************
 * DONE 函数重定义区
 ****************************************************************************************************
 */

// //串口输出重定
void USART_printf (UART_HandleTypeDef  *huart,char *fmt, ...)
{
    char buff[RX_BUFFER_SIZE+1];//用于存放转换后的数据 [长度]
    uint16_t i=0;
    va_list arg_ptr;
    va_start(arg_ptr, fmt);
    vsnprintf(buff, RX_BUFFER_SIZE+1, fmt,  arg_ptr);//数据转换
    i=strlen(buff);//得出数据长度
    if(strlen(buff)>RX_BUFFER_SIZE)i=RX_BUFFER_SIZE;//如果长度大于最大值，则长度等于最大值（多出部分忽略）
    // HAL_UART_Transmit(huart,(uint8_t  *)buff,i,0xffff);//串口发送函数（串口号，内容，数量，溢出时间）
    if (HAL_UART_Transmit(huart, (uint8_t  *)buff, i, 1000) != HAL_OK) {
        Error_Handler(); // 超时处理
    }
    va_end(arg_ptr);
}

/**
 * @brief 串口中断回调函数
 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) 
{
    if (huart->Instance == USART1) 
	{
            // 检查是否接收到完整数据包（根据协议定义）
            // 检测数据帧结束
            if (usart1_rxIndex > (FRAME_HEADER_LENGTH + FRAME_TAIL_LENGTH))
            {
                // 如果接收到 'C'，表示新数据包开始
                if (rxBuffer_2[0] == 'C')
                {
                    HMI_arry_length = 0;
                }

                // 将接收到的数据存入 HMI_arry
                for (uint8_t i = 0; i <= rxIndex_1; i++)
                {
                    if (HMI_arry_length < RX_BUFFER_SIZE)
                    {
                        HMI_arry[HMI_arry_length++] = rxBuffer_1[i];
                    }
                }

                // 检查是否为有效 NMEA 数据包（以 "CONN" 开头）
                // if (HMI_arry[0] == 'C' && HMI_arry[1] == 'O' && HMI_arry[2] == 'N'&& HMI_arry[3] == 'N')
                // {
                //     if(HMI_arry[rxIndex_1] == 'D' && HMI_arry[rxIndex_1-1] == 'N' && HMI_arry[rxIndex_1-2] == 'E')
                //     {
                        Receivedsuccee_Flag = 1;  // 标记帧接收完成  
                        usart1_ready = 1;         // 设置标志位
                //     }

                // }

                // 清空缓冲区并重置索引
                memset(rxBuffer_1, 0, RX_BUFFER_SIZE);
                memset(HMI_arry, 0, RX_BUFFER_SIZE);
                HMI_arry_length = 0;
                rxIndex_1 = 0;
            }
            else
            {
                rxIndex_1++; // 增加索引
            }

            
        // // 检查是否接收到完整帧 
        // if(usart1_rxIndex > (FRAME_HEADER_LENGTH + FRAME_TAIL_LENGTH))
        // {
        //     // 检查帧头 
        //     if(memcmp(rxBuffer_1, FRAME_HEADER2, FRAME_HEADER_LENGTH) == 0)
        //     {
        //         // 检查帧尾
        //         if(memcmp(&rxBuffer_1[usart1_rxIndex - FRAME_TAIL_LENGTH], FRAME_TAIL, FRAME_TAIL_LENGTH) == 0)
        //         {
        //             Receivedsuccee_Flag = 1;  // 标记帧接收完成
        //             // usart1_packet_len = usart1_rxIndex;
        //             usart1_ready = 1; // 设置标志位
        //             // UARTHMI_ParsePacket(huart,rxBuffer_1,8);
        //         }
        //     }
        // }
            
        // 防止缓冲区溢出 
        if(usart1_rxIndex < RX_BUFFER_SIZE - 1)
        {
            usart1_rxIndex++;
            // 重新启动接收中断 
            HAL_UART_Receive_IT(huart, &rxBuffer_1[usart1_rxIndex], 1);
        }
        else
        {
            // 缓冲区溢出，重置索引 
            usart1_rxIndex = 0;
            HAL_UART_Receive_IT(huart, &rxBuffer_1[usart1_rxIndex], 1);
        }
    }
	else if (huart->Instance == USART2) 
	{
        if(GPS_START_FLAG == 0)
        {
            wifi.BUFF[ wifi.buff_length++]= rxBuffer_2[rxIndex_2];
        }
        else if(GPS_START_FLAG == 1)
        {
            // 检查是否接收到完整数据包（根据协议定义）
            // 检测数据帧结束
            if (rxBuffer_2[rxIndex_2] == '\n' || rxIndex_2 >= RX_BUFFER_SIZE - 1)
            {
                // 如果接收到 '$'，表示新数据包开始
                if (rxBuffer_2[0] == '$')
                {
                    GPS_arry_length = 0;
                }

                // 将接收到的数据存入 GPS_arry
                for (uint8_t i = 0; i <= rxIndex_2; i++)
                {
                    if (GPS_arry_length < BUFF_MAX)
                    {
                        GPS_arry[GPS_arry_length++] = rxBuffer_2[i];
                    }
                }

                // 检查是否为有效 NMEA 数据包（以 "$GxRMC" 开头）
                if (GPS_arry[0] == '$' && GPS_arry[4] == 'M' && GPS_arry[5] == 'C')
                {
                    memset(gps.Frame_Buffer, 0, BUFF_MAX);                  // 清空 GPS 缓冲区
                    memcpy(gps.Frame_Buffer, GPS_arry, GPS_arry_length);    // 将数据复制到 GPS 缓冲区
                    gps.buff_flag = 1;                                      // 设置标志位
                }

                // 清空缓冲区并重置索引
                memset(rxBuffer_2, 0, RX_BUFFER_SIZE);
                memset(GPS_arry, 0, BUFF_MAX);
                GPS_arry_length = 0;
                rxIndex_2 = 0;
            }
            else
            {
                rxIndex_2++; // 增加索引
            }
        }

        // 继续接收下一个字节
        HAL_UART_Receive_IT(&huart2, (uint8_t *)&rxBuffer_2[rxIndex_2], 1);
    }
	// else if (huart->Instance == USART3) 
	// {
    //     // 检查是否接收到完整数据包（根据协议定义）
    //     if (rxBuffer_3[rxIndex_3] == '\n' || rxIndex_3 >= RX_BUFFER_SIZE - 1) 
	// 	{
    //         // 结束符或缓冲区满，解析数据包
    //         UART_ParsePacket(bt24_huart,rxBuffer_3, rxIndex_3);
    //         rxIndex_3 = 0; // 重置接收索引
    //     } 
	// 	else 
	// 	{
    //         rxIndex_3++; // 增加索引
    //     }
    //     // 继续接收下一个字节
    //     HAL_UART_Receive_IT(&huart3, (uint8_t *)&rxBuffer_3[rxIndex_3], 1);
    // }
	else if (huart->Instance == UART4) 
	{
        // 检查是否接收到完整数据包（根据协议定义）
        if (rxBuffer_4[rxIndex_4] == '\n' || rxIndex_4 >= RX_BUFFER_SIZE - 1) 
		{
            // 结束符或缓冲区满，解析数据包
            UART_ParsePacket(Test_huart,rxBuffer_4, rxIndex_4);
            rxIndex_4 = 0; // 重置接收索引
        } 
		else 
		{
            rxIndex_4++; // 增加索引
        }
        // 继续接收下一个字节
        HAL_UART_Receive_IT(&huart4, (uint8_t *)&rxBuffer_4[rxIndex_4], 1);
    }
}



// void HAL_UART_IdleCpltCallback(UART_HandleTypeDef *huart)
// {
//     if (huart->Instance == USART2) // 判断是哪个串口触发了空闲中断
//     {
//         /* 清除空闲中断标志 */
//         __HAL_UART_CLEAR_IDLEFLAG(huart);

//         wifi.BUFF[ wifi.buff_length++]= rxBuffer_2[rxIndex_2];
//         wifi.buff_flag = 1;

//         /* 重新启动接收 */
//         HAL_UART_Receive_IT(&huart2, (uint8_t *)&rxBuffer_2[rxIndex_2], 1);
//     }
// }


/**
 * @brief 错误回调函数
 */
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) {
    if (huart->Instance == USART1) 
	{
        // 处理错误
        __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_ORE); // 清除溢出标志
        HAL_UART_Receive_IT(&huart1, (uint8_t *)&rxBuffer_1[rxIndex_1], 1); // 重新启动接收
    }
	else if (huart->Instance == USART2) 
	{
        // 处理错误
        __HAL_UART_CLEAR_FLAG(&huart2, UART_FLAG_ORE); // 清除溢出标志
        HAL_UART_Receive_IT(&huart2, (uint8_t *)&rxBuffer_2[rxIndex_2], 1); // 重新启动接收
    }
	else if (huart->Instance == USART3) 
	{
        // 处理错误
        __HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_ORE); // 清除溢出标志
        HAL_UART_Receive_IT(&huart3, (uint8_t *)&rxBuffer_3[rxIndex_3], 1); // 重新启动接收
    }
	else if (huart->Instance == UART4) 
	{
        // 处理错误
        __HAL_UART_CLEAR_FLAG(&huart4, UART_FLAG_ORE); // 清除溢出标志
        HAL_UART_Receive_IT(&huart4, (uint8_t *)&rxBuffer_4[rxIndex_4], 1); // 重新启动接收
    }
}


/**
 ****************************************************************************************************
 * DONE 用户函数区
 ****************************************************************************************************
 */

#if UART_SEND_MODE == 1
/**
  * @brief 发送数据包
  * @param huart 串口句柄
  * @param pParket 数据指针
  * @param length 数据长度
  */
void uart_sendBuffer(UART_HandleTypeDef *huart,uint8_t *pParket,uint16_t length)
{
	if (length > TX_BUFFER_SIZE) return; // 防止溢出
	while(length--)
	{

		if(HAL_UART_Transmit(huart,pParket,1,HAL_MAX_DELAY)!=HAL_OK)
		{
			return;
		}
		while (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) == RESET);
		pParket++;
	}
}

#elif UART_SEND_MODE == 2

/**
 * @brief 发送数据包
 * @param huart 串口句柄
 * @param data 数据指针
 * @param length 数据长度
 */
void UART_SendPacket(UART_HandleTypeDef *huart,uint8_t *data, uint16_t length) 
{
    if (length > TX_BUFFER_SIZE) return; // 防止溢出
	if (huart->Instance == USART1)
	{
		memcpy(txBuffer_1, data, length);
		HAL_UART_Transmit(&huart, txBuffer_1, length, HAL_MAX_DELAY);
	}
    else if (huart->Instance == USART2)
	{
		memcpy(txBuffer_2, data, length);
		HAL_UART_Transmit(&huart, txBuffer_2, length, HAL_MAX_DELAY);
	}
	else if (huart->Instance == USART3)
	{
		memcpy(txBuffer_3, data, length);
		HAL_UART_Transmit(&huart, txBuffer_3, length, HAL_MAX_DELAY);
	}
	else if (huart->Instance == UART4)
	{
		memcpy(txBuffer_4, data, length);
		HAL_UART_Transmit(&huart, txBuffer_4, length, HAL_MAX_DELAY);
	}
}

#endif


/**
 * @brief 解析接收到串口的数据包
 * @param packet 数据包
 * @param length 数据包长度
 */
void UART_ParsePacket(UART_HandleTypeDef *huart,uint8_t *packet, uint16_t length) 
{
	// 将数据包转换为字符串
    char data[length+1];
    memcpy(data, packet, length);
    data[length] = '\0'; // 确保字符串以 NULL 结尾

    // 检查数据包
    if (strncmp(data, "PID", 3) == 0) 
    {
        // int pid_sign;
        // float kp, ki, kd;
        // if (sscanf(data, "PID %d %f %f %f END", &pid_sign, &kp, &ki, &kd) == 4) \
        // {
        //     // 成功解析
        //     if(pid_sign == 1) PID_Init( &speed_pid, kp, ki, kd,10);
        //     else if(pid_sign == 2) PID_Init( &position_pid, kp, ki, kd,10);
        //     else if(pid_sign == 3) PID_Init( &pitch_pid, kp, ki, kd,10);
        //     else if(pid_sign == 4) PID_Init( &roll_pid, kp, ki, kd,10);

        //     uint8_t print[]="pid ok\n";
        //     uart_sendBuffer(huart,print,sizeof(print));
        // } 
        // else 
        // {
        //     uint8_t print[]="Invalid PID Packet Format\n";
        //     uart_sendBuffer(huart,print,sizeof(print));
        // }
    }
    else if (strncmp(data, "CON", 3) == 0) 
    {
        // float position, speed;
        // if (sscanf(data, "CON %f %f END", &position, &speed) == 2) 
        // {
        //     // 成功解析
        //     MOTOR_GotoTarget(position, speed);

        //     uint8_t print[]="con ok\n";
        //     uart_sendBuffer(huart,print,sizeof(print));
        // } 
        // else
        // {
        //     uint8_t print[]="Invalid CON Packet Format\n";
        //     uart_sendBuffer(huart,print,sizeof(print));
        // }
    }
    else if (strncmp(data, "RUN", 3) == 0) 
    {
        // int left_pwm, right_pwm;
        // if (sscanf(data, "RUN %d %d END", &left_pwm, &right_pwm) == 2) 
        // {
        //     // 成功解析
        //     MOTOR_Move((int16_t)left_pwm, (int16_t)right_pwm);
        
        //     uint8_t print[]="run ok\n";
        //     uart_sendBuffer(huart,print,sizeof(print));
            
        // } 
        // else
        // {
        //     uint8_t print[]="Invalid RUN Packet Format\n";
        //     uart_sendBuffer(huart,print,sizeof(print));
        // }
    }
    // 未知数据包格式
    else 
    {
        // uint8_t print[]="Unknown Packet Format\n";
        // uart_sendBuffer(huart,print,sizeof(print));
    }
    
}

/**
 * @brief 解析接收到串口屏的数据包
 * @param packet 数据包
 * @param length 数据包长度
 */
void UARTHMI_ParsePacket(UART_HandleTypeDef *huart,uint8_t *packet, uint16_t usart1_rxIndex) 
{
    if(Receivedsuccee_Flag)
    {
        // 提取数据部分（去掉头和尾）
        uint8_t dataLength = usart1_rxIndex - FRAME_HEADER_LENGTH - FRAME_TAIL_LENGTH;
        uint8_t data[dataLength],run_stopflag = 0;
        memcpy(data, &packet[FRAME_HEADER_LENGTH], dataLength);
        SHIP_DIR run_dir;
        
        // 执行相应操作 
        if(dataLength == 1)
        {
            switch (data[0])
            {
            case 'F':run_dir = SHIP_FRONT;    break;
            case 'B':run_dir = SHIP_FRONT;    break;
            case 'L':run_dir = SHIP_FRONT;    break;
            case 'R':run_dir = SHIP_FRONT;    break;
            case 'S':run_stopflag = 1;        break;
            default:run_stopflag = 1;
                break;
            }
        }
        if(run_stopflag)    Motor_stop(1);
        else SHIP_RUN(50,50,run_dir);
        USART_printf(bt24_huart,"CONN %c END\r\n",data[0]);
        run_stopflag = 0;    
        // 重置接收状态 
        Receivedsuccee_Flag = 0;
        memset(rxBuffer_1, 0, RX_BUFFER_SIZE);  
        usart1_rxIndex = 0;     
        usart1_ready = 0;
        
    }

}

/**
 * @brief 解析接收到4G模块的数据包
 * @param packet 数据包
 * @param length 数据包长度
 */
void G4_UART_ParsePacket(UART_HandleTypeDef *huart,uint8_t *packet, uint16_t length) 
{
    // // 将数据包转换为字符串
    // char data[length+1];
    // memcpy(data, packet, length);
    // data[length] = '\0'; // 确保字符串以 NULL 结尾

    // // 检查数据包
    // if (strncmp(data, "OK", 2) == 0) 
    // {
    //     USART_printf(G4_huart,"%s",data);
    // }
    // else if(strncmp(data, "NETOPEN:0", 2) == 0)
    // {
    //     USART_printf(G4_huart,"%s",data);
    // }
    // else if(strncmp(data, "NETOPEN:SUCCESS", 2) == 0)
    // {
    //     USART_printf(G4_huart,"%s",data);
    // }
    // else if(strncmp(data, "MIPSTART: SUCCESS", 2) == 0)
    // {
    //     USART_printf(G4_huart,"%s",data);
    // }
    // else
    // {
    //     uint8_t print[]="Unknown Packet Format\n";
    //     uart_sendBuffer(huart,print,sizeof(print));
    // }
}


/**
  * @brief 数据包格式转换（数字转换为字符串）
  * @param adcData 数据接口
  * @param buffer 数据加工存放包
  * @param bufferLength 数据加工存放包长度
  */

void Num_To_String(uint8_t (*data)[6][4],uint8_t (*buffer)[6],uint16_t ADC_index,uint16_t Num_index)
{
        if (buffer[ADC_index][ADC_index] >= 100) {
            data[ADC_index][Num_index][0] = '0' + buffer[ADC_index][ADC_index] / 100;
            data[ADC_index][Num_index][1] = '0' + (buffer[ADC_index][ADC_index] / 10) % 10;
            data[ADC_index][Num_index][2] = '0' + buffer[ADC_index][ADC_index] % 10;
            data[ADC_index][Num_index][3] = '\0';
        } else if (buffer[ADC_index][ADC_index] >= 10) {
            data[ADC_index][Num_index][0] = '0' + buffer[ADC_index][ADC_index] / 10;
            data[ADC_index][Num_index][1] = '0' + buffer[ADC_index][ADC_index] % 10;
            data[ADC_index][Num_index][2] = '\0';
        } else {
            data[ADC_index][Num_index][0] = '0' + buffer[ADC_index][ADC_index];
            data[ADC_index][Num_index][1] = '\0';
        }
}

/**
 ****************************************************************************************************
 * DONE 初始化和进程区
 ****************************************************************************************************
 */

/**
 * @name 串口初始化函数
 * @brief 对串口的初始化（串口1->bearpi、串口2->4G、串口3->蓝牙调试、串口4）
 */
void uart_Init(void)
{
	HAL_UART_Receive_IT(&huart1, (uint8_t *)&rxBuffer_1[rxIndex_1], 1);
	HAL_UART_Receive_IT(&huart2, (uint8_t *)&rxBuffer_2[rxIndex_2], 1);
	HAL_UART_Receive_IT(&huart3, (uint8_t *)&rxBuffer_3[rxIndex_3], 1);
	HAL_UART_Receive_IT(&huart4, (uint8_t *)&rxBuffer_4[rxIndex_4], 1);
	
	// HAL_Delay(100);
}


void uart_Test(UART_HandleTypeDef *huart)
{
    USART_printf(huart,"UART TEST OK");
}

